Application servers form a foundation for developing and executing c-commerce applications, providing the presentation, business and information access logic, security and management services, and the underlying infrastructure needed for highly scalable and mission critical software applications. An application server typically supports a variety of clients, such as web browsers and wireless devices, as well as different operating systems, databases, message queues and legacy systems. As such, applications servers have traditionally provided the advantages of data and code integrity, centralized configuration, security, transactional support and overall cost benefits for various software applications.
Today, applications servers are often repackaged by numerous middleware products in order to provide additional functionality on top of the application server. As an illustration, a middleware product may provide functionality that allows all applications on the server to perform specialized functions, such as event monitoring or security services. In many cases, these higher layer middleware products leverage the deployment infrastructure of the application server. In such cases, hooks are usually provided to the application server in order to listen for various deployment events. The hooks can then be used by the middleware products to execute additional code upon deploying an application (e.g. additional code that provides the functionality of the higher layer product). As an example, a security product may need to execute code in order to track various security events for all servlets on the server. Similarly, a monitoring product may need to include code that monitors all applications, and the like.
However, the hooks used to execute additional functionality are often difficult to maintain and frequently require changes to the application server for each new type of integration. A subset of such integration scenarios require a mere extension to application behavior, either in terms of application code, or application configuration. This can be thought of as the application extension problem.
Some of these difficulties can be partially resolved by the use of shared libraries. A shared library contains application fragments that can be merged into the user application at deployment time. Higher layer products can thus provide their own shared application libraries that their users can refer to from their applications. However, this typically requires the user to explicitly add such a reference. Asking a user to add an explicit reference to their application is less usable and tedious on the software developer. In addition, it is often quite possible that the user will forget to add the reference(s). In such cases, the application would deploy without problems, yet would behave incorrectly, thereby increasing the testing and debugging efforts. What is needed is a more user friendly approach to repackaging the application server in order to extend functionality of the applications deployed thereon. Applicants have identified the foregoing as well as other needs that currently exist in the art in coming to conceive the subject matter of the present disclosure.